package com.jzo2o.knife4j.utils;


import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;

import javax.servlet.ServletOutputStream;
import javax.servlet.WriteListener;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;

/**
 * 响应包装器，用于拦截并缓存HTTP响应数据
 */
public class ResponseWrapper extends HttpServletResponseWrapper {
    // 字节数组输出流，用于临时缓存响应数据
    private ByteArrayOutputStream buffer = null;
    // 包装后的Servlet输出流
    private ServletOutputStream out = null;
    // 包装后的字符打印流
    private PrintWriter writer = null;
    /**
     * 构造方法，初始化响应包装器及缓存流
     * @param resp 原始HTTP响应对象
     * @throws IOException IO异常
     */
    public ResponseWrapper(HttpServletResponse resp) throws IOException {
        super(resp);
        buffer = new ByteArrayOutputStream();// 真正存储数据的流
        out = new WapperedOutputStream(buffer);
        writer = new PrintWriter(new OutputStreamWriter(buffer));
    }

    /**
     * 获取包装后的Servlet输出流
     */
    @Override
    public ServletOutputStream getOutputStream() throws IOException {
        return out;
    }

    /**
     * 获取包装后的字符打印流
     */
    @Override
    public PrintWriter getWriter() throws UnsupportedEncodingException {
        return writer;
    }

    /**
     * 刷新缓冲区，将数据写入底层输出流
     */
    @Override
    public void flushBuffer() throws IOException {
        if (out != null) {
            out.flush();
        }
        if (writer != null) {
            writer.flush();
        }
    }

    /**
     * 重置缓冲区数据
     */
    @Override
    public void reset() {
        buffer.reset();
    }

    /**
     * 获取缓存的响应数据（字节数组形式）
     * @return 响应数据字节数组
     * @throws IOException IO异常
     */
    public byte[] getResponseData() throws IOException {
        flushBuffer();
        return buffer.toByteArray();
    }

    /**
     * 获取缓存的响应数据（字符串形式）
     * @return 响应数据字符串
     * @throws IOException IO异常
     */
    public String getContent() throws IOException{
        flushBuffer();
        return buffer.toString();
    }

    /**
     * 内部类，包装ServletOutputStream，将数据写入缓存流
     */
    private class WapperedOutputStream extends ServletOutputStream {
        // 字节数组输出流，实际存储响应数据
        private ByteArrayOutputStream bos = null;
        /**
         * 构造方法，绑定缓存流
         * @param stream 目标字节数组输出流
         */
        public WapperedOutputStream(ByteArrayOutputStream stream) throws IOException {
            bos = stream;
        }

        /**
         * 写入单个字节到缓存流
         */
        @Override
        public void write(int b) throws IOException {
            bos.write(b);
        }


        /**
         * 写入字节数组到缓存流
         */
        @Override
        public void write(byte[] b) throws IOException {
            bos.write(b, 0, b.length);
        }

        /**
         * 写入字节数组指定区间到缓存流
         */
        @Override
        public void write(byte[] b, int off, int len) throws IOException {
            bos.write(b, off, len);
        }

        /**
         * 标记输出流是否就绪（简化实现，返回false）
         */
        @Override
        public boolean isReady() {
            return false;
        }

        /**
         * 设置写入监听器（空实现，暂不支持异步写入）
         */
        @Override
        public void setWriteListener(WriteListener writeListener) {

        }
    }
}
